Peer-to-Peer Secure Multi-Party Numerical Computation Facing Malicious Adversaries

We propose an efficient framework for enabling secure multi-party numerical computations in a Peer-to-Peer network. This problem arises in a range of applications such as collaborative filtering, distributed computation of trust and reputation, monitoring and other tasks, where the computing nodes is expected to preserve the privacy of their inputs while performing a joint computation of a certain function. Although there is a rich literature in the field of distributed systems security concerning secure multi-party computation, in practice it is hard to deploy those methods in very large scale Peer-to-Peer networks. In this work, we try to bridge the gap between theoretical algorithms in the security domain, and a practical Peer-to-Peer deployment. We consider two security models. The first is the semi-honest model where peers correctly follow the protocol, but try to reveal private information. We provide three possible schemes for secure multi-party numerical computation for this model and identify a single light-weight scheme which outperforms the others. Using extensive simulation results over real Internet topologies, we demonstrate that our scheme is scalable to very large networks, with up to millions of nodes. The second model we consider is the malicious peers model, where peers can behave arbitrarily, deliberately trying to affect the results of the computation as well as compromising the privacy of other peers. For this model we provide a fourth scheme to defend the execution of the computation against the malicious peers. The proposed scheme has a higher complexity relative to the semi-honest model. Overall, we provide the Peer-to-Peer network designer a set of tools to choose from, based on the desired level of security.Comment: Submitted to Peer-to-Peer Networking and Applications Journal (PPNA) 200

On implementing omega in systems with weak reliability and synchrony assumptions

We study the feasibility and cost of implementing Omega --- a fundamental failure detector at the core of many algorithms ---in systems with weak reliability and synchrony assumptions. Intuitively, Omega allows processes to eventually elect a common leader. We first give an algorithm that implements Omega in a weak system S where (a) except for some unknown timely process s, all processes may be arbitrarily slow or may crash, and (b) only the output links of s are eventually timely (all other links can be arbitrarily slow and lossy). Previously known algorithms for Omega worked only in systems that are strictly stronger than S in terms of reliability or synchrony assumptions. We next show that algorithms that implement $\Omega$ in system S are necessarily expensive in terms of communication complexity: all correct processes (except possibly one) must send messages forever; moreover, a quadratic number of links must carry messages forever.This result holds even for algorithms that tolerate at most one crash. Finally, we show that with a small additional assumption to system S--- the existence of some unknown correct process whoselinks can be arbitrarily slow and lossy but fair ---there is a communication-efficient algorithm for Omega such that eventually only one process (the elected leader) sends messages. Some recent experimental results indicate that two of the algorithms for Omega described in this paper can be used in dynamically-changing systems and work well in practice~ST0

On subsidies and home-ownership: Colombian housing policy during the 1990s

In the early 1990s, the World Bank began to recommend that governments reform their national housing, land and financial sectors in ways that would 'enable the market to work'. Chile and Colombia have both taken this advice seriously. Unfortunately, Colombian experience demonstrates that while some elements in the new approach are eminently sensible, there are certain flaws. Offering subsidies for homes but not for services is highly questionable and the criticism made of sites and services schemes is inappropriate. A further weakness of the Washington approach is the sacrifice of rental accommodation on the altar of owner-occupation

Online Checkpointing with Improved Worst-Case Guarantees

Abstract. In the online checkpointing problem, the task is to continuously maintain a set of k checkpoints that allow to rewind an ongoing computation faster than by a full restart. The only operation allowed is to remove an old checkpoint and to store the current state instead. Our aim are checkpoint placement strategies that minimize rewinding cost, i.e., such that at all times T when requested to rewind to some time t ≤ T the number of computation steps that need to be redone to get to t from a checkpoint before t is as small as possible. In particular, we want that the closest checkpoint earlier than t is not further away from t than pk times the ideal distance T/(k + 1), where pk is a small constant. Improving over earlier work showing 1 + 1/k ≤ pk ≤ 2, we show that pk can be chosen less than 2 uniformly for all k. More precisely, we show the uniform bound pk ≤ 1.7 for all k, and present algorithms with asymptotic performance pk ≤ 1.59 + o(1) valid for all k and pk ≤ ln(4) + o(1) ≤ 1.39+o(1) valid for k being a power of two. For small values of k, we show how to use a linear programming approach to compute good checkpointing algorithms. This gives performances of less than 1.53 for k ≤ 10. One the more theoretical side, we show the first lower bound that is asymptotically more than one, namely pk ≥ 1.30 − o(1). We also show that optimal algorithms (yielding the infimum performance) exist for all k.

[Ill D. B. Johnson and W. Zwaenepoel, “Recovery in distributed systems

[8] S. Feldman and C. Brown, “A system for program debugging vi